home *** CD-ROM | disk | FTP | other *** search
/ PC Media 3 / PC MEDIA CD03.iso / share / prog / qmath10 / quad3_16.asm < prev    next >
Encoding:
Assembly Source File  |  1993-07-12  |  5.7 KB  |  348 lines
  1. .model small,pascal
  2. .386
  3.  
  4. if @DataSize
  5.  
  6. LES_ equ les
  7. ES_ equ es:
  8. PUSH_ macro x
  9. push word ptr (x)+2
  10. push word ptr (x)
  11. endm
  12.  
  13. else
  14.  
  15. LES_ equ mov
  16. ES_ equ ds:
  17. PUSH_ macro x
  18. push x
  19. endm
  20.  
  21. endif
  22.  
  23. quad    struc
  24. q0    dd    ?
  25. q1    dd    ?
  26. quad    ends
  27.  
  28. .code
  29.  
  30. ;-----------------------------------------------------------------------------
  31. ;void pascal quadinc(quad* z, quad x)
  32. ;compute z=z+x
  33.  
  34. public    QUADINC
  35. QUADINC    proc    z:ptr, x:qword
  36.  
  37.     mov    eax,(x).q0
  38.     mov    edx,(x).q1
  39.     LES_    bx,z
  40.     add    ES_[bx].q0,eax
  41.     adc    ES_[bx].q1,edx
  42.     ret
  43.  
  44. QUADINC    endp
  45.  
  46. ;-----------------------------------------------------------------------------
  47. ;void pascal quadinca(quad* z, quad* x)
  48. ;compute z=z+x
  49.  
  50. public    QUADINCA
  51. QUADINCA    proc    z:ptr, x:ptr
  52.  
  53.     LES_    bx,x
  54.     mov    eax,ES_[bx].q0
  55.     mov    edx,ES_[bx].q1
  56.     LES_    bx,z
  57.     add    ES_[bx].q0,eax
  58.     adc    ES_[bx].q1,edx
  59.     ret
  60.  
  61. QUADINCA    endp
  62.  
  63. ;-----------------------------------------------------------------------------
  64. ;void pascal quaddec(quad* z, quad x)
  65. ;compute z=z-x
  66.  
  67. public    QUADDEC
  68. QUADDEC    proc    z:ptr, x:qword
  69.  
  70.     mov    eax,(x).q0
  71.     mov    edx,(x).q1
  72.     LES_    bx,z
  73.     sub    ES_[bx].q0,eax
  74.     sbb    ES_[bx].q1,edx
  75.     ret
  76.  
  77. QUADDEC    endp
  78.  
  79. ;-----------------------------------------------------------------------------
  80. ;void pascal quaddeca(quad* z, quad* x)
  81. ;compute z=z-x
  82.  
  83. public    QUADDECA
  84. QUADDECA    proc    z:ptr, x:ptr
  85.  
  86.     LES_    bx,x
  87.     mov    eax,ES_[bx].q0
  88.     mov    edx,ES_[bx].q1
  89.     LES_    bx,z
  90.     sub    ES_[bx].q0,eax
  91.     sbb    ES_[bx].q1,edx
  92.     ret
  93.  
  94. QUADDECA    endp
  95.  
  96. ;-----------------------------------------------------------------------------
  97. ;void pascal quadadd(quad* z, quad x, quad y)
  98. ;compute z=x+y
  99.  
  100. public    QUADADD
  101. QUADADD    proc    z:ptr, x:qword, y:qword
  102.  
  103.     mov    eax,(x).q0
  104.     mov    edx,(x).q1
  105.     add    eax,(y).q0
  106.     adc    edx,(y).q1
  107.     LES_    bx,z
  108.     mov    ES_[bx].q0,eax
  109.     mov    ES_[bx].q1,edx
  110.     ret
  111.  
  112. QUADADD    endp
  113.  
  114. ;-----------------------------------------------------------------------------
  115. ;void pascal quadadda(quad* z, quad* x, quad* y)
  116. ;compute z=x+y
  117.  
  118. public    QUADADDA
  119. QUADADDA    proc    z:ptr, x:ptr, y:ptr
  120.  
  121.     LES_    bx,x
  122.     mov    eax,ES_[bx].q0
  123.     mov    edx,ES_[bx].q1
  124.     LES_    bx,y
  125.     add    eax,ES_[bx].q0
  126.     adc    edx,ES_[bx].q1
  127.     LES_    bx,z
  128.     mov    ES_[bx].q0,eax
  129.     mov    ES_[bx].q1,edx
  130.     ret
  131.  
  132. QUADADDA    endp
  133.  
  134. ;-----------------------------------------------------------------------------
  135. ;void pascal quadsub(quad* z, quad x, quad y)
  136. ;compute z=x-y
  137.  
  138. public    QUADSUB
  139. QUADSUB    proc    z:ptr, x:qword, y:qword
  140.  
  141.     mov    eax,(x).q0
  142.     mov    edx,(x).q1
  143.     sub    eax,(y).q0
  144.     sbb    edx,(y).q1
  145.     LES_    bx,z
  146.     mov    ES_[bx].q0,eax
  147.     mov    ES_[bx].q1,edx
  148.     ret
  149.  
  150. QUADSUB    endp
  151.  
  152. ;-----------------------------------------------------------------------------
  153. ;void pascal quadsuba(quad* z, quad* x, quad* y)
  154. ;compute z=x-y
  155.  
  156. public    QUADSUBA
  157. QUADSUBA    proc    z:ptr, x:ptr, y:ptr
  158.  
  159.     LES_    bx,x
  160.     mov    eax,ES_[bx].q0
  161.     mov    edx,ES_[bx].q1
  162.     LES_    bx,y
  163.     sub    eax,ES_[bx].q0
  164.     sbb    edx,ES_[bx].q1
  165.     LES_    bx,z
  166.     mov    ES_[bx].q0,eax
  167.     mov    ES_[bx].q1,edx
  168.     ret
  169.  
  170. QUADSUBA    endp
  171.  
  172. ;-----------------------------------------------------------------------------
  173. ;void pascal quadmult(quad* z, quad x, quad y)
  174. ;compute z=x*y
  175.  
  176. public    QUADMULT
  177. QUADMULT    proc    z:ptr, x:qword, y:qword
  178.  
  179.     mov    eax,(x).q0
  180.     mov    ebx,eax
  181.     mul    (y).q1
  182.     xchg    eax,ebx
  183.     mov    ecx,(y).q0
  184.     mul    ecx
  185.     add    ebx,edx
  186.     xchg    eax,ecx
  187.     mul    (x).q1
  188.     add    eax,ebx
  189.     LES_    bx,z
  190.     mov    ES_[bx].q0,ecx
  191.     mov    ES_[bx].q1,eax
  192.     ret
  193.  
  194. QUADMULT    endp
  195.  
  196. ;-----------------------------------------------------------------------------
  197. ;void pascal quadmulta(quad* z, quad* x, quad* y)
  198. ;compute z=x*y
  199.  
  200. public    QUADMULTA
  201. QUADMULTA    proc    uses si, z:ptr, x:ptr, y:ptr
  202.  
  203.     LES_    bx,x
  204.     mov    esi,ES_[bx].q0
  205.     mov    ecx,ES_[bx].q1
  206.     LES_    bx,y
  207.     mov    eax,ES_[bx].q1
  208.     mov    ebx,ES_[bx].q0
  209.     mul    esi
  210.     xchg    eax,ecx
  211.     mul    ebx
  212.     add    ecx,eax
  213.     mov    eax,ebx
  214.     mul    esi
  215.     add    edx,ecx
  216.     LES_    bx,z
  217.     mov    ES_[bx].q0,eax
  218.     mov    ES_[bx].q1,edx
  219.     ret
  220.  
  221. QUADMULTA    endp
  222.  
  223. ;-----------------------------------------------------------------------------
  224. ;void pascal quaddiv(quad* z, quad x, quad y)
  225. ;compute z=x/y
  226.  
  227. public    QUADDIV
  228. QUADDIV    proc    uses si di, z:ptr, x:qword, y:qword
  229.  
  230.     xor    di,di        ;sign
  231.  
  232.     mov    eax,(x).q0
  233.     mov    edx,(x).q1
  234.     or    edx,edx
  235.     jns    quaddiv1
  236.  
  237.     inc    di
  238.     neg    eax
  239.     adc    edx,0
  240.     neg    edx
  241.     mov    (x).q1,edx
  242.     mov    (x).q0,eax
  243. quaddiv1:
  244.     mov    ebx,(y).q0
  245.     mov    esi,(y).q1
  246.     or    esi,esi
  247.     jns    quaddiv2
  248.  
  249.     inc    di
  250.     neg    ebx
  251.     adc    esi,0
  252.     neg    esi
  253. quaddiv2:
  254.     jnz    quaddiv3    ;y >= 2^16?
  255.  
  256. ;---------------------------------------
  257. ;y < 2^16:
  258.  
  259.     or    ebx,ebx
  260.     jz    quaddiv9    ;divide by zero?
  261.  
  262.     mov    ecx,eax
  263.     mov    eax,edx
  264.     xor    edx,edx
  265.     div    ebx
  266.     xchg    eax,ecx
  267.     div    ebx
  268.     jmp    quaddiv6
  269.  
  270. ;---------------------------------------
  271. ;y >= 2^16:
  272.  
  273. quaddiv3:
  274.     bsr    ecx,esi        ;shift right x and y so that y<2^16
  275.     inc    cl
  276.     push    ebx
  277.     shrd    ebx,esi,cl
  278.     shrd    eax,edx,cl
  279.     shr    edx,cl
  280.  
  281.     div    ebx        ;estimate z
  282.  
  283.     mov    ebx,eax        ;multiply z with y
  284.     mul    esi
  285.     mov    ecx,eax
  286.     pop    eax
  287.     mul    ebx
  288.     add    edx,ecx
  289.  
  290.     jc    quaddiv4    ;compare z*y with x
  291.     cmp    edx,(x).q1
  292.     ja    quaddiv4
  293.     jb    quaddiv5
  294.     cmp    eax,(x).q0
  295.     jbe    quaddiv5
  296. quaddiv4:
  297.     dec    ebx        ;decrement z if z*y > x
  298. quaddiv5:
  299.     xor    ecx,ecx
  300.     mov    eax,ebx
  301.  
  302. ;---------------------------------------
  303. quaddiv6:
  304.     dec    di
  305.     jnz    quaddiv7
  306.  
  307.     neg    eax        ;change sign of result
  308.     adc    ecx,0
  309.     neg    ecx
  310.  
  311. quaddiv7:
  312.     LES_    bx,z
  313.     mov    ES_[bx].q0,eax
  314.     mov    ES_[bx].q1,ecx
  315.     ret
  316.  
  317. quaddiv9:            ;divide error
  318.     xor    eax,eax
  319.     dec    eax
  320.     mov    ecx,7fffffffh
  321.     jmp    quaddiv6    ;return 7fffffffffffffffh
  322.  
  323. QUADDIV    endp
  324.  
  325. ;-----------------------------------------------------------------------------
  326. ;void pascal quaddiva(quad* z, quad* x, quad* y)
  327. ;compute z=x*y
  328.  
  329. public    QUADDIVA
  330. QUADDIVA    proc    z:ptr, x:ptr, y:ptr
  331.  
  332.     PUSH_    z
  333.     LES_    bx,x
  334.     push    ES_[bx].q1
  335.     push    ES_[bx].q0
  336.     LES_    bx,y
  337.     push    ES_[bx].q1
  338.     push    ES_[bx].q0
  339.     call    QUADDIV
  340.  
  341.     ret
  342.  
  343. QUADDIVA    endp
  344.  
  345. ;-----------------------------------------------------------------------------
  346. end
  347.  
  348.